\documentclass[a4paper,12pt]{article} 
\usepackage{german} 
\usepackage{umlaute}
\begin{document} 
\sloppy
\tableofcontents

\section{Einleitung}
\subsection{Was ist es?}
``selftree.inc'' ist ein in der PoVRay-Scriptsprache geschriebener
Include-File-Generator. Die erzeugten Includefiles enthalten ein oder
mehrere Objekte, die bei guter Wahl der Parameter recht brauchbare
Bäume ergeben.

Form, Aussehen und Komplexizität der erzeugten Objekte sind durch eine
Vielzahl von Parametern beeinflußbar. 

Die folgende Anleitung muß nicht komplett gelesen werden, um mit der
Datei umgehen zu können. Zur Anwendung reicht der Abschnitt über die
Benutzung und die Erlärung der einzelnen Variablen und der Blätter.
Die restlichen Abschnitte enthalten allgemeines Gelaber
und ein paar für andere POVRay-Programmierer interessante
Beschreibungen der Funktionsweise des Files.

\subsection{Motivation}
Die Idee, ein Bäume erzeugendes Include-File zu schreiben hatte
ursprünglich ein Mathematikstudent (Hallo, Holger!), dessen Files aber
keine Rekursion enthielten, sondern verschiedene Schachtelungen von
verschiedenen Include-Files. Zehn Stufen Rekursion = zehn
verschiedene Include-Files... Nach langer Diskussion, wie man dieses
Problem lösen könnte und dem definitiven Beweis, daß Rekursion in
POVRay derzeit nicht möglich ist, packte mich der Ehrgeiz, eben doch
ein rekursives Include-File zu schreiben. Heraus kam selftree.inc.

\section{Benutzung}
\subsection{Allgemein}
Um die von ``selftree.inc'' erzeugten Bäume benutzen zu können, ist
ein kleiner Trick notwendig. Das Programm schreibt den Source-Code der
er\-zeug\-ten Objekte per \#debug-Anweisung in den Debug-Stream. Um das
Objekt im Scene-File benutzen zu können, muß man den Debug-Stream also
in eine Datei umleiten. Das geht mit der Anweisung -GD\_FILENAME\_
(bzw. +GD\-\_FILE\-NA\-ME\_, wenn man die Ausgabe von ``selftree.inc'' auch
gleichzeitig auf der Console betrachten möchte, was aber nicht nötig
ist, da der erzeugte Code selber nicht sonderlich interessant ist und
eine Statistik über die erzeugten Objekte wird nach dem Parsen
derselben auf dem Statistik-Stream aus\-ge\-ge\-ben). Diese Anweisung leitet
den Debug-Stream in die Datei \_FILENAME\_ um. Diese Datei wiederum muß
{\bf nach} ``selftree.inc'' in das Scene-File ein\-ge\-bun\-den werden. Und
noch vor alledem sollte man einen Haufen Variablen setzen, um das
Aussehen des Baumes zu beeinflussen (wobei auch die Default-Werte
schon einen brauchbaren Baum erzeugen).

Folgende Schritte sind also nötig, um mit ``selftree.inc'' einen Baum
zu erzeugen:
\begin{itemize}
\item{Einen Haufen Variablen setzen (oder mit dem Standardbaum
zufrieden sein).}
\item{``selftree.inc'' in das Scene-File einbinden.}
\item{Evtl. mehrfach die ersten beiden Schritte wiederholen, um
mehrere Bäume zu erzeugen.}
\item{\_FILENAME\_ in das Scene-File einbinden. Wobei \_FILENAME\_ der Name
der mit dem POVRay-Aufruf erzeugten Datei ist.}
\item{object-Statement mit dem erzeugten Baum-Object deklarieren:\\
object \{ TREE texture \{...\} rotate \{...\} translate \{...\}\}}
\item{POVRay aufrufen, etwa so:\\
{\bf povray +Imyscene.pov -GD\_FILENAME\_}... weitere POVRay-Argumente}
\end{itemize}


\subsection{Variablen}
``selftree.inc'' kann durch eine große Anzahl von Variablen beeinflußt
werden. Es gibt im Grunde genommen drei verschiedene Arten von
Variablen:
\begin{itemize}
\item{Einfache Zahlen: Davon gibt es nur zwei namens DEPTH und NRLEAFINCS.}
\item{Stringvariablen, die bei der Deklaration in Anführungszeichen
eingebunden werden müssen und einen normalen String am
besten ohne Leer- und Sonderzeichen enthalten sollten. Beispiel:\\
{\bf \#declare OBJECTNAME = ``mytree''}}
\item{Funktionen: Der größte Teil aller Variablen sind Funktionen,
deren Wert in Abhängigkeit von der aktuellen Rekursionsstufe berechnet
wird. Die Funktionen können konstante Werte haben ({\bf \#declare
NRBRANCHES = ``3''}) oder als Funktionen in Abhängigkeit von X (großes X)
angegeben werden ({\bf \#declare NRBRANCHES =
``int(sqrt(X)+(X/2))''})}. Diese Art Werte zu setzen hat den Vorteil,
das erzeugte Objekt weitaus genauer beeinflussen zu können. So kann
man z.B. mit einfachen Funktionen schon den Baum in den Spitzen mehr
verzweigt sein lassen, als weiter unten bei den noch dickeren Ästen.
\end{itemize}
Bis auf DEPTH, NRLEAFINCS und die Textur-Modifier erwartet
``selftree.inc'' alle Variablen in Anführungszeichen definiert.

``selftree.inc'' nimmt keine Überprüfung der Variablen vor. Es wird
(sicherlich fälschlicherweise) davon ausgegangen, daß nie irgendjemand
einen Fehler macht, und wenn doch, er es schon selber merken wird...

Die Werte vieler Variablen werden bei der Erzeugung des Baums noch
durch zufallsabhängige Funktionen beeinflußt, so daß die Ergebnisse
nicht immer genau vorhersagbar sind (man kann bei ansonsten gleichen
Einstellungen und nur verändertem Startwert einer der
Zufallsgeneratoren sehr verschiedene Bäume erhalten), ein bißchen
Übung und Glück helfen, gute Werte zu finden.

Es folgt nun eine Beschreibung aller Variablen, die gesetzt werden
können, einschließlich ihrer Default-Werte und Vorschläge für
sinnvolle Wertebereiche. (Eine kurze Referenz der Variablen findet man
im Include-file selbst.) Und dann ran ans rendern...

\subsubsection{OBJECTNAME}
\begin{enumerate}
\item{Beschreibung:} Um mehrere verschiedene erzeugte Bäume
unterscheiden zu können, muß man ihnen Namen geben. Die in dieser
Variablen gesetzten Namen sind dann die Objekt-Bezeichner, unter denen
man die Bäume im Scene-File benutzen kann.
\item{Default:} ``TREE'' (Stringvariable)
\item{Anmerkungen:} Erzeugt man durch mehrfaches Einfügen von
``selftree.inc'' mehrere Bäume, ohne OBJECTNAME jedesmal neu zu
setzen, haben alle erzeugen Objekte den gleichen Namen, was zu
unerwünschten Effekten führen kann.
\end{enumerate}

\subsubsection{USESTDTRUNK}
\begin{enumerate}
\item{Beschreibung:} Die erzeugten Bäume bestehen aus cone-Objekten
mit Kugeln an den Enden, um die Übergänge weicher zu gestalten. Um
einem Baum realitätsnäher erscheinen zu lassen, kann man einen eigenen
Stamm definieren, den ``selftree.inc'' dann statt des Standardstamms
benutzt. Diese Variable ist ein Bool, der anzeigt, ob der
Standardstamm oder ein anderer benutzt werden soll.
\item{Default:} ``YES''
\end{enumerate}

\subsubsection{TRUNKLEN}
\begin{enumerate}
\item{Beschreibung:} Wie lang soll der Stamm sein? Die Angabe gilt
sowohl für den Standardstamm wie auch für selbstdefinierte.
\item{Default:} ``5''
\end{enumerate}

\subsubsection{TRUNKBASER}
\begin{enumerate}
\item{Beschreibung:} Welchen Radius soll der Standardstamm am Boden
haben?
\item{Default:} ``0.7''
\end{enumerate}

\subsubsection{TRUNKCAPR}
\begin{enumerate}
\item{Beschreibung:} Welchen Radius soll der Standardstamm an der
Spitze haben?
\item{Default:} ``0.5''
\end{enumerate}

\subsubsection{DEPTH}
\begin{enumerate}
\item{Beschreibung:} DEPTH gibt die Rekursionstiefe an, d.h. wie oft
der Baum vom Stamm bis zu den Astspitzen verzweigt.
\item{Default:} 6
\item{Anmerkungen:} Diese Variable muß nicht in Anführungszeichen
definiert werden.
\end{enumerate}

\subsubsection{BLEN}
\begin{enumerate}
\item{Beschreibung:} Die Länge der Äste in der ersten Rekursionsstufe
(die Äste, die direkt vom Stamm abzweigen). 
\item{Default:} ``5''
\item{Anmerkungen:} Es wird nur die Länge dieser Äste benötigt, da die
weiteren Äste skalierte und zufällig leicht variierte Versionen dieser
Äste sind.
\end{enumerate}

\subsubsection{LDIFF}
\begin{enumerate}
\item{Beschreibung:} Der Bereich, in dem die Länge der Äste zufällig
variieren darf.
\item{Default:} ``0''
\item{Anmerkungen:} Der Wert aus diesem Bereich wird zu BLEN
addiert. Dieser Wert wird ebenfalls mit skaliert in den
Rekursionsstufen.
\end{enumerate}

\subsubsection{RADIUS}
\begin{enumerate}
\item{Beschreibung:} Der Startradius der Äste der ersten
Rekursionsstufe. 
\item{Default:} ``0.5''
\item{Anmerkungen:} Für einen weichen Übergang sollte man hier am
besten den gleichen Wert wie für TRUNKCAPR nehmen.
\end{enumerate}

\subsubsection{RADSCALE}
\begin{enumerate}
\item{Beschreibung:} Der Skalierungswert für den Astradius zwischen
den Rekursionsstufen.
\item{Default:} ``0.5''
\end{enumerate}

\subsubsection{RDIFF}
\begin{enumerate}
\item{Beschreibung:} Der Bereich, in dem der RADIUS zufällig variieren
darf. 
\item{Default:} ``0''
\item{Anmerkungen:} Wird von RADIUS abgezogen und ebenfalls
mitskaliert. 
\end{enumerate}

\subsubsection{RECSCALE}
\begin{enumerate}
\item{Beschreibung:} Der allgemeine Skalierungswert für die
Rekursion.
Skalierungswert haben.
\item{Default:} ``0.5''
\item{Anmerkungen:} Dieser Faktor gilt für alle Werte, die keinen
eigenen Skalierungswert haben.
\end{enumerate}

\subsubsection{SLOPEANGLE}
\begin{enumerate}
\item{Beschreibung:} Der Winkel, in dem die Äste von ihren Vorgängern
abzweigen. 
\item{Default:} ``40''
\end{enumerate}

\subsubsection{SANGLEDIFF}
\begin{enumerate}
\item{Beschreibung:} Der Bereich, in dem SLOPEANGLE variieren darf.
\item{Default:} ``0''
\item{Anmerkungen:} Wird zu SLOPEANGLE addiert.
\end{enumerate}

\subsubsection{ANGLESCALE}
\begin{enumerate}
\item{Beschreibung:} Der Skalierungswert für SLOPEANGLE.
\item{Default:} ``1.1''
\end{enumerate}

\subsubsection{NRBRANCHES}
\begin{enumerate}
\item{Beschreibung:} Die Anzahl der Kind-Äste die von einem Ast,
bzw. dem Stamm abzweigen. 
\item{Default:} ``4''
\item{Anmerkungen:} Hier machen kleine Funktionen in Abhängigkeit von X Sinn
und geben sehr interessante Bäume (VORSICHT: Man sollte darauf achten,
daß die Funktionswerte nicht zu groß wachsen, die Anzahl Objekte aus
denen der Baum besteht, nimmt extrem schnell astronomische Werte an!).
\end{enumerate}

\subsubsection{NRBDIFF}
\begin{enumerate}
\item{Beschreibung:} Der Bereich, in dem die Anzahl der Äste
(NRBRANCHES) variieren darf. 
\item{Default:} ``0''
\item{Anmerkungen:} Wird zu NRBRANCHES addiert.
\end{enumerate}

\subsubsection{NRBSCALEADD}
\begin{enumerate}
\item{Beschreibung:} Einer von zwei Skalierungswerten für die Anzahl
der Äste. 
\item{Default:} ``0''
\item{Anmerkungen:} Dieser Wert ist ein Überbleibsel aus alten
Versionen, als ``selftree.inc'' noch keine Funktionen als Variablen
kannte, und kann besser durch eine Funktion in NRBRANCHES ersetzt
werden. Wenn man allerdings keine eigenen Funktionen schreiben mag,
sind dieser und der folgende Wert gute Möglichkeiten, NRBRANCHES zu
variieren. 

Der Wert wird in jeder Rekursionsstufe zu NRBRANCHES addiert.
\end{enumerate}

\subsubsection{NRBSCALEMUL}
\begin{enumerate}
\item{Beschreibung:} Der zweite Skalierungswert für NRBRANCHES.
\item{Default:} ``1''
\item{Anmerkungen:} NRBRANCHES wird in jeder Rekursionsstufe mit
NRBSCALEMUL multipliziert. Siehe auch Anmerkung zu NRBSCALEADD.
\end{enumerate}

\subsubsection{BRANCHTOP}
\begin{enumerate}
\item{Beschreibung:} Ein Schwellenwert, der die Wahrscheinlichkeit
angibt, mit der ein Ast von der Spitze seines Vorgänger abzweigt.
\item{Default:} ``0.6''
\item{Anmerkungen:} Ist ein zufällig zwischen 0 und 1 gewürfelter Wert
größer als BRANCHTOP, verzweigt der Ast an einer beliebigen Stelle
seines Vorgängers, sonst an dessen Spitze.
\end{enumerate}

\subsubsection{LEAFINC}
\begin{enumerate}
\item{Beschreibung:} Hat der Baum Blätter?
\item{Default:} ``NO''
\end{enumerate}

\subsubsection{NRLEAFINCS}
\begin{enumerate}
\item{Beschreibung:} Wie viele verschiedene Blätter gibt es?
\item{Default:} 0
\item{Anmerkungen:} Dieser Wert wird {\bf ohne} Anführungszeichen
angegeben.

Es müssen bestimmte Blattobjekte definiert werden, die
``selftree.inc'' benutzt. Siehe hierzu Kapitel 3 über Blätter.
\end{enumerate}

\subsubsection{NRLEAFS}
\begin{enumerate}
\item{Beschreibung:} Wieviele Blätter soll ein Ast haben? 
\item{Default:} ``0''
\item{Anmerkungen:} Es werden nur an den äußersten Äste Blätter
angebracht. 
\end{enumerate}

\subsubsection{NRLDIFF}
\begin{enumerate}
\item{Beschreibung:} Der Bereich, in dem NRLEAFS variieren darf.
\item{Default:} ``0''
\item{Anmerkungen:} Wird zu NRLEAFS addiert.
\end{enumerate}

\subsubsection{ROTRANGE}
\begin{enumerate}
\item{Beschreibung:} Der Bereich, in dem Äste um ihren Vorgänger
rotiert und verteilt werden.
\item{Default:} ``360''
\item{Anmerkungen:} Mit ein bißchen Geschick kann man mit einer
Einschränkung dieses Wertes Phänomene wie Wind simulieren.
\end{enumerate}

\subsubsection{RANDINIT\_ROT}
\begin{enumerate}
\item{Beschreibung:} Startwert für den Zufallsgenerator für ROTRANGE
\item{Default:} ``1.1234''
\item{Anmerkungen:} Die Änderung eines dieser Wert kann das Aussehen
des Baumes sehr verändern. Ist ein Baum z.B. strukturell gut gelungen,
aber seine Form befriedig nicht, kann das Ändern eines dieser Werte
den Baum deutlich verbessern (oder verschlechtern...).
\end{enumerate}

\subsubsection{RANDINIT\_LDIFF}
\begin{enumerate}
\item{Beschreibung:} Startwert für den Zufallsgenerator für LDIFF.
\item{Default:} ``0.1234''
\end{enumerate}

\subsubsection{RANDINIT\_RDIFF}
\begin{enumerate}
\item{Beschreibung:} Startwert für den Zufallsgenerator für RDIFF.
\item{Default:} ``0.1234''
\end{enumerate}

\subsubsection{RANDINIT\_SDIFF}
\begin{enumerate}
\item{Beschreibung:} Startwert für den Zufallsgenerator für SANGLEDIFF.
\item{Default:} ``0.1234''
\end{enumerate}

\subsubsection{RANDINIT\_NRBDIFF}
\begin{enumerate}
\item{Beschreibung:} Startwert für den Zufallsgenerator für NRBDIFF.
\item{Default:} ``0.1234''
\end{enumerate}

\subsubsection{RANDINIT\_NRLDIFF}
\begin{enumerate}
\item{Beschreibung:} Startwert für den Zufallsgenerator für NRLDIFF.
\item{Default:} ``0.1234''
\end{enumerate}

\subsubsection{RANDINIT\_LEAFSELECT}
\begin{enumerate}
\item{Beschreibung:} Startwert für den Zufallsgenerator für die
zufällige Auswahl der verschiedenen Blätter.
\item{Default:} ``0.1234''
\end{enumerate}

\subsubsection{RANDINIT\_LEAFTRANS}
\begin{enumerate}
\item{Beschreibung:} Startwert für den Zufallsgenerator für die
Plazierung der Blätter an den Ästen.
\item{Default:} ``0.1234''
\end{enumerate}

\subsubsection{RANDINIT\_LEAFROT}
\begin{enumerate}
\item{Beschreibung:} Startwert für den Zufallsgenerator für die
zufällige Rotation der Blätter um die Äste.
\item{Default:} ``0.1234''
\end{enumerate}

\subsubsection{RANDINIT\_BT}
\begin{enumerate}
\item{Beschreibung:} Startwert für den Zufallsgenerator zum Auswürfeln
der Schwellenwerte für BRANCHTOP.
\item{Default:} ``0.1234''
\end{enumerate}

\subsubsection{MOD\_TR}
\begin{enumerate}
\item{Beschreibung:} Textur für den Stamm.
\item{Default:} es wird die \#default-Textur verwendet.
\item{Anmerkungen:} Es sollte eine vollständige Textur-Definition
angegeben werden. Beispiel:
\begin{verbatim}
texture {
   pigment {
      color DarkBrown
   }
   normal {
      bozo 0.2 
      scale <0.05, 0.2, 0.08>
   }
}
\end{verbatim}
\end{enumerate}

\subsubsection{MOD\_X}
\begin{enumerate}
\item{Beschreibung:} Die Texturen für die Äste der verschiedenen
Rekursionsstufen.
\item{Default:} es wird die \#default-Textur verwendet.
\item{Anmerkungen:} Das X im Namen dieser Variable ist ein
Platzhalter. X ist eine Nummer zwischen 0 und DEPTH-1 (0 sind die
Äste, die direkt vom Stamm abzweigen, DEPTH-1 die obersten
Astspitzen). Auf diese Weise kann für die Äste jeder Rekursionsstufe
eine eigene Textur angegeben werden (es macht z.B. Sinn, die Textur
bei den äußeren dünneren Ästen weniger grob und rauh sein zu lassen).
\end{enumerate}

\subsubsection{\#default}
\begin{enumerate}
\item{Beschreibung:} Eine Default-Textur für den Baum.
\item{Default:} \{ pigment \{ color rgb $<0.35, 0.16, 0.14>$ \} \}
\item{Anmerkungen:} Hat man eine eigene Default-Textur definiert,
sollte man diese vor Verwendung von ``selftree.inc'' sichern und
anschließend restaurieren.
\end{enumerate}

\section{Blätter}
Um nicht nur winterliche Bäume erzeugen zu können, kann man mit
``selftree.inc'' natürlich auch Blätter hinzufügen. Dafür müssen
Blattobjekte definiert werden. ``selftree.inc'' erlaubt, verschiedene
Blattformen an einem Baum zu verteilen. Wieviele verschiedene Formen
es gibt, wird durch die Variable NRLEAFINCS festgelegt.

Die Namen der Blattobjekte folgen einem festen Schema, damit
``selftree.inc'' die Namen der Blätter kennt. Blätternamen müssen
folgendermaßen aufgebaut sein: LEAFINC\_X. X steht dabei für eine Zahl
zwischen 0 und NRLEAFINCS-1. Hat NRLEAFINCS also den Wert 11, erwartet
``selftree.inc'' die Namen LEAFINC\_0, LEAFINC\_1, ..., LEAFINC\_10. 

Es wird davon ausgegangen, daß der Blattstiel am Punkt $<0,0,0>$
seinen Ursprung hat und das Blatt in Y-Richtung ausgerichtet ist.

Eine Blattdefinition kann z.B. so aussehen:
\begin{verbatim}
#declare LEAFINC_0 =
sphere
{
  <0, 0, 0>, 0.3
  scale <1, 0.1, 0.5>
  translate <0.3, 0, 0>
  pigment { color Green }
}
\end{verbatim}

\subsection{leafshapes.inc}
Das in der Distribution mitgelieferte ``leafshapes.inc'' bietet eine
kleine Auswahl an vordefinierten Blättern. Das Scenefile leafs.pov
erzeugt ein Bild aller vordefinierten Blätter mit ihren Namen.

\section{Funktionsweise}
Um echte Rekursion zu erzeugen, muß man in POVRay leider auf einen
Trick zurückgreifen: Über die ausreichend mächtigen
Stringfunktionen bastelt man sich POVRay-Anweisungen und
schreibt diese per Debug-Stream (oder eines beliebigen für Benutzer
vorgesehenen Streams) und der der entsprechenden
Komanndozeilenanweisung (für den Debug-Stream -GD\_FILENAME\_) in eine
Datei, die ebenfalls in das Scenefile eingebunden wird.

Um dabei dann Rekursion zu erhalten, muß der erzeugte Sourcecode
einfach endrekursiv, also aus verschachtelten Schleifenanweisungen
bestehen. Das ist der ganze Trick.

Möchte man die Rekursionsstiefe noch variabel halten, kann man statt
direkter Verschachtelungen auch einfach zwei hintereinander gestellte
while-Schleifen nehmen, die erste öffnet alle Rekursionsstufen, die
zweite schließt sie wieder.

\section{Allgemeines}
\subsection{Historie}
\begin{enumerate}
\item{Version 1.0:}
Dies ist die erste richtige Zusammenstellung der Include-Files. Vorige
Versionen wurden zwar auch schon herumgereicht, aber immer mit
unbearbeiteten Source-Codes und ohne richtige (und vor allem
unvollständiger) Anleitung.
\end{enumerate}

\subsection{Todo}
\begin{enumerate}
\item{Frei definierbare Objekte für die Astformen, um die Äste
interessanter zu formen.}
\item{Ein ``Translation-Tracker'', um die Äste und Blätter nach
bestimmten angegebenen Richtungen zu orientieren (Schwerkraft, Wind,
etc.)}
\item{Ausgabekosmetic mit korrekt eingerückten erzeugten Sourcecodes.}
\item{``Joker-Variablen'', die bestimmte vordefinierte Klassen von
Bäumen erzeugen (klein und verwuchert, hoch und schlank oder aber
Eichen-ähnlich, Pinien-ähnlich etc. --- ein sehr utopisches Ziel...) }
\item{Erweitertes und verbessertes leafshapes.inc}
\item{Auswahl an Rinden-Texturen in bark.inc}
\item{Erzeugen anderer Pflanzen durch Angabe einer Pflanzenklasse (es
ist auch zur Zeit schon möglich, durch geschickte Auswahl der
Parameter z.B. einen Kaktus zu erzeugen, aber nicht viel mehr...).}
\item{Überprüfen der Variablen-Werte vor dem Erzeugen der Bäume.}
\item{Die default-texture restaurieren.}
\end{enumerate}

\subsection{Bugs}
Vermutlich schon, sind mir aber noch nicht aufgefallen. Wer welche
findet oder Fragen und Vorschläge hat, kann mit mailen:
darüber bitte an:

stk@informatik.uni-bremen.de\\
(http://www.informatik.uni-bremen.de/~$\tilde{}$~stk)

\subsection{Dankeschön}
Dank für Motivation und viele gute Ideen bei der Realisierung an die
beiden anderen Mitglieder meiner POVRay-Spielgruppe Holger Bettag
(http://www.informatik.uni-bremen.de/~$\tilde{}$~hobold) und Harald Wagener
(http://www.informatik.uni-bremen.de/~$\tilde{}$~hollow). 

\subsection{Copyright}
Obwohl POVRay nicht direkt aus dem Bereich der GNU-Ecke kommt, stelle
ich das Include unter dessen Lizenzbedingungen (Version 2 oder nach
belieben neuer), siehe dazu die Datei COPYRIGHT.
\end{document}
